home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / lang / AbstractStringBuilder.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  8.3 KB  |  628 lines
  1. package java.lang;
  2.  
  3. import java.util.Arrays;
  4. import sun.misc.FloatingDecimal;
  5.  
  6. abstract class AbstractStringBuilder implements Appendable, CharSequence {
  7.    char[] value;
  8.    int count;
  9.    static final int[] sizeTable = new int[]{9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999, Integer.MAX_VALUE};
  10.  
  11.    AbstractStringBuilder() {
  12.    }
  13.  
  14.    AbstractStringBuilder(int var1) {
  15.       this.value = new char[var1];
  16.    }
  17.  
  18.    public int length() {
  19.       return this.count;
  20.    }
  21.  
  22.    public int capacity() {
  23.       return this.value.length;
  24.    }
  25.  
  26.    public void ensureCapacity(int var1) {
  27.       if (var1 > this.value.length) {
  28.          this.expandCapacity(var1);
  29.       }
  30.  
  31.    }
  32.  
  33.    void expandCapacity(int var1) {
  34.       int var2 = (this.value.length + 1) * 2;
  35.       if (var2 < 0) {
  36.          var2 = Integer.MAX_VALUE;
  37.       } else if (var1 > var2) {
  38.          var2 = var1;
  39.       }
  40.  
  41.       this.value = Arrays.copyOf(this.value, var2);
  42.    }
  43.  
  44.    public void trimToSize() {
  45.       if (this.count < this.value.length) {
  46.          this.value = Arrays.copyOf(this.value, this.count);
  47.       }
  48.  
  49.    }
  50.  
  51.    public void setLength(int var1) {
  52.       if (var1 < 0) {
  53.          throw new StringIndexOutOfBoundsException(var1);
  54.       } else {
  55.          if (var1 > this.value.length) {
  56.             this.expandCapacity(var1);
  57.          }
  58.  
  59.          if (this.count < var1) {
  60.             while(this.count < var1) {
  61.                this.value[this.count] = 0;
  62.                ++this.count;
  63.             }
  64.          } else {
  65.             this.count = var1;
  66.          }
  67.  
  68.       }
  69.    }
  70.  
  71.    public char charAt(int var1) {
  72.       if (var1 >= 0 && var1 < this.count) {
  73.          return this.value[var1];
  74.       } else {
  75.          throw new StringIndexOutOfBoundsException(var1);
  76.       }
  77.    }
  78.  
  79.    public int codePointAt(int var1) {
  80.       if (var1 >= 0 && var1 < this.count) {
  81.          return Character.codePointAt(this.value, var1);
  82.       } else {
  83.          throw new StringIndexOutOfBoundsException(var1);
  84.       }
  85.    }
  86.  
  87.    public int codePointBefore(int var1) {
  88.       int var2 = var1 - 1;
  89.       if (var2 >= 0 && var2 < this.count) {
  90.          return Character.codePointBefore(this.value, var1);
  91.       } else {
  92.          throw new StringIndexOutOfBoundsException(var1);
  93.       }
  94.    }
  95.  
  96.    public int codePointCount(int var1, int var2) {
  97.       if (var1 >= 0 && var2 <= this.count && var1 <= var2) {
  98.          return Character.codePointCountImpl(this.value, var1, var2 - var1);
  99.       } else {
  100.          throw new IndexOutOfBoundsException();
  101.       }
  102.    }
  103.  
  104.    public int offsetByCodePoints(int var1, int var2) {
  105.       if (var1 >= 0 && var1 <= this.count) {
  106.          return Character.offsetByCodePointsImpl(this.value, 0, this.count, var1, var2);
  107.       } else {
  108.          throw new IndexOutOfBoundsException();
  109.       }
  110.    }
  111.  
  112.    public void getChars(int var1, int var2, char[] var3, int var4) {
  113.       if (var1 < 0) {
  114.          throw new StringIndexOutOfBoundsException(var1);
  115.       } else if (var2 >= 0 && var2 <= this.count) {
  116.          if (var1 > var2) {
  117.             throw new StringIndexOutOfBoundsException("srcBegin > srcEnd");
  118.          } else {
  119.             System.arraycopy(this.value, var1, var3, var4, var2 - var1);
  120.          }
  121.       } else {
  122.          throw new StringIndexOutOfBoundsException(var2);
  123.       }
  124.    }
  125.  
  126.    public void setCharAt(int var1, char var2) {
  127.       if (var1 >= 0 && var1 < this.count) {
  128.          this.value[var1] = var2;
  129.       } else {
  130.          throw new StringIndexOutOfBoundsException(var1);
  131.       }
  132.    }
  133.  
  134.    public AbstractStringBuilder append(Object var1) {
  135.       return this.append(String.valueOf(var1));
  136.    }
  137.  
  138.    public AbstractStringBuilder append(String var1) {
  139.       if (var1 == null) {
  140.          var1 = "null";
  141.       }
  142.  
  143.       int var2 = var1.length();
  144.       if (var2 == 0) {
  145.          return this;
  146.       } else {
  147.          int var3 = this.count + var2;
  148.          if (var3 > this.value.length) {
  149.             this.expandCapacity(var3);
  150.          }
  151.  
  152.          var1.getChars(0, var2, this.value, this.count);
  153.          this.count = var3;
  154.          return this;
  155.       }
  156.    }
  157.  
  158.    public AbstractStringBuilder append(StringBuffer var1) {
  159.       if (var1 == null) {
  160.          return this.append("null");
  161.       } else {
  162.          int var2 = var1.length();
  163.          int var3 = this.count + var2;
  164.          if (var3 > this.value.length) {
  165.             this.expandCapacity(var3);
  166.          }
  167.  
  168.          var1.getChars(0, var2, this.value, this.count);
  169.          this.count = var3;
  170.          return this;
  171.       }
  172.    }
  173.  
  174.    public AbstractStringBuilder append(CharSequence var1) {
  175.       if (var1 == null) {
  176.          var1 = "null";
  177.       }
  178.  
  179.       if (var1 instanceof String) {
  180.          return this.append((String)var1);
  181.       } else {
  182.          return var1 instanceof StringBuffer ? this.append((StringBuffer)var1) : this.append((CharSequence)var1, 0, ((CharSequence)var1).length());
  183.       }
  184.    }
  185.  
  186.    public AbstractStringBuilder append(CharSequence var1, int var2, int var3) {
  187.       if (var1 == null) {
  188.          var1 = "null";
  189.       }
  190.  
  191.       if (var2 >= 0 && var3 >= 0 && var2 <= var3 && var3 <= ((CharSequence)var1).length()) {
  192.          int var4 = var3 - var2;
  193.          if (var4 == 0) {
  194.             return this;
  195.          } else {
  196.             int var5 = this.count + var4;
  197.             if (var5 > this.value.length) {
  198.                this.expandCapacity(var5);
  199.             }
  200.  
  201.             for(int var6 = var2; var6 < var3; ++var6) {
  202.                this.value[this.count++] = ((CharSequence)var1).charAt(var6);
  203.             }
  204.  
  205.             this.count = var5;
  206.             return this;
  207.          }
  208.       } else {
  209.          throw new IndexOutOfBoundsException("start " + var2 + ", end " + var3 + ", s.length() " + ((CharSequence)var1).length());
  210.       }
  211.    }
  212.  
  213.    public AbstractStringBuilder append(char[] var1) {
  214.       int var2 = this.count + var1.length;
  215.       if (var2 > this.value.length) {
  216.          this.expandCapacity(var2);
  217.       }
  218.  
  219.       System.arraycopy(var1, 0, this.value, this.count, var1.length);
  220.       this.count = var2;
  221.       return this;
  222.    }
  223.  
  224.    public AbstractStringBuilder append(char[] var1, int var2, int var3) {
  225.       int var4 = this.count + var3;
  226.       if (var4 > this.value.length) {
  227.          this.expandCapacity(var4);
  228.       }
  229.  
  230.       System.arraycopy(var1, var2, this.value, this.count, var3);
  231.       this.count = var4;
  232.       return this;
  233.    }
  234.  
  235.    public AbstractStringBuilder append(boolean var1) {
  236.       if (var1) {
  237.          int var2 = this.count + 4;
  238.          if (var2 > this.value.length) {
  239.             this.expandCapacity(var2);
  240.          }
  241.  
  242.          this.value[this.count++] = 't';
  243.          this.value[this.count++] = 'r';
  244.          this.value[this.count++] = 'u';
  245.          this.value[this.count++] = 'e';
  246.       } else {
  247.          int var3 = this.count + 5;
  248.          if (var3 > this.value.length) {
  249.             this.expandCapacity(var3);
  250.          }
  251.  
  252.          this.value[this.count++] = 'f';
  253.          this.value[this.count++] = 'a';
  254.          this.value[this.count++] = 'l';
  255.          this.value[this.count++] = 's';
  256.          this.value[this.count++] = 'e';
  257.       }
  258.  
  259.       return this;
  260.    }
  261.  
  262.    public AbstractStringBuilder append(char var1) {
  263.       int var2 = this.count + 1;
  264.       if (var2 > this.value.length) {
  265.          this.expandCapacity(var2);
  266.       }
  267.  
  268.       this.value[this.count++] = var1;
  269.       return this;
  270.    }
  271.  
  272.    public AbstractStringBuilder append(int var1) {
  273.       if (var1 == Integer.MIN_VALUE) {
  274.          this.append("-2147483648");
  275.          return this;
  276.       } else {
  277.          int var2 = var1 < 0 ? stringSizeOfInt(-var1) + 1 : stringSizeOfInt(var1);
  278.          int var3 = this.count + var2;
  279.          if (var3 > this.value.length) {
  280.             this.expandCapacity(var3);
  281.          }
  282.  
  283.          Integer.getChars(var1, var3, this.value);
  284.          this.count = var3;
  285.          return this;
  286.       }
  287.    }
  288.  
  289.    static int stringSizeOfInt(int var0) {
  290.       int var1;
  291.       for(var1 = 0; var0 > sizeTable[var1]; ++var1) {
  292.       }
  293.  
  294.       return var1 + 1;
  295.    }
  296.  
  297.    public AbstractStringBuilder append(long var1) {
  298.       if (var1 == Long.MIN_VALUE) {
  299.          this.append("-9223372036854775808");
  300.          return this;
  301.       } else {
  302.          int var3 = var1 < 0L ? stringSizeOfLong(-var1) + 1 : stringSizeOfLong(var1);
  303.          int var4 = this.count + var3;
  304.          if (var4 > this.value.length) {
  305.             this.expandCapacity(var4);
  306.          }
  307.  
  308.          Long.getChars(var1, var4, this.value);
  309.          this.count = var4;
  310.          return this;
  311.       }
  312.    }
  313.  
  314.    static int stringSizeOfLong(long var0) {
  315.       long var2 = 10L;
  316.  
  317.       for(int var4 = 1; var4 < 19; ++var4) {
  318.          if (var0 < var2) {
  319.             return var4;
  320.          }
  321.  
  322.          var2 = 10L * var2;
  323.       }
  324.  
  325.       return 19;
  326.    }
  327.  
  328.    public AbstractStringBuilder append(float var1) {
  329.       (new FloatingDecimal(var1)).appendTo(this);
  330.       return this;
  331.    }
  332.  
  333.    public AbstractStringBuilder append(double var1) {
  334.       (new FloatingDecimal(var1)).appendTo(this);
  335.       return this;
  336.    }
  337.  
  338.    public AbstractStringBuilder delete(int var1, int var2) {
  339.       if (var1 < 0) {
  340.          throw new StringIndexOutOfBoundsException(var1);
  341.       } else {
  342.          if (var2 > this.count) {
  343.             var2 = this.count;
  344.          }
  345.  
  346.          if (var1 > var2) {
  347.             throw new StringIndexOutOfBoundsException();
  348.          } else {
  349.             int var3 = var2 - var1;
  350.             if (var3 > 0) {
  351.                System.arraycopy(this.value, var1 + var3, this.value, var1, this.count - var2);
  352.                this.count -= var3;
  353.             }
  354.  
  355.             return this;
  356.          }
  357.       }
  358.    }
  359.  
  360.    public AbstractStringBuilder appendCodePoint(int var1) {
  361.       if (!Character.isValidCodePoint(var1)) {
  362.          throw new IllegalArgumentException();
  363.       } else {
  364.          int var2 = 1;
  365.          if (var1 >= 65536) {
  366.             ++var2;
  367.          }
  368.  
  369.          int var3 = this.count + var2;
  370.          if (var3 > this.value.length) {
  371.             this.expandCapacity(var3);
  372.          }
  373.  
  374.          if (var2 == 1) {
  375.             this.value[this.count++] = (char)var1;
  376.          } else {
  377.             Character.toSurrogates(var1, this.value, this.count);
  378.             this.count += var2;
  379.          }
  380.  
  381.          return this;
  382.       }
  383.    }
  384.  
  385.    public AbstractStringBuilder deleteCharAt(int var1) {
  386.       if (var1 >= 0 && var1 < this.count) {
  387.          System.arraycopy(this.value, var1 + 1, this.value, var1, this.count - var1 - 1);
  388.          --this.count;
  389.          return this;
  390.       } else {
  391.          throw new StringIndexOutOfBoundsException(var1);
  392.       }
  393.    }
  394.  
  395.    public AbstractStringBuilder replace(int var1, int var2, String var3) {
  396.       if (var1 < 0) {
  397.          throw new StringIndexOutOfBoundsException(var1);
  398.       } else if (var1 > this.count) {
  399.          throw new StringIndexOutOfBoundsException("start > length()");
  400.       } else if (var1 > var2) {
  401.          throw new StringIndexOutOfBoundsException("start > end");
  402.       } else {
  403.          if (var2 > this.count) {
  404.             var2 = this.count;
  405.          }
  406.  
  407.          int var4 = var3.length();
  408.          int var5 = this.count + var4 - (var2 - var1);
  409.          if (var5 > this.value.length) {
  410.             this.expandCapacity(var5);
  411.          }
  412.  
  413.          System.arraycopy(this.value, var2, this.value, var1 + var4, this.count - var2);
  414.          var3.getChars(this.value, var1);
  415.          this.count = var5;
  416.          return this;
  417.       }
  418.    }
  419.  
  420.    public String substring(int var1) {
  421.       return this.substring(var1, this.count);
  422.    }
  423.  
  424.    public CharSequence subSequence(int var1, int var2) {
  425.       return this.substring(var1, var2);
  426.    }
  427.  
  428.    public String substring(int var1, int var2) {
  429.       if (var1 < 0) {
  430.          throw new StringIndexOutOfBoundsException(var1);
  431.       } else if (var2 > this.count) {
  432.          throw new StringIndexOutOfBoundsException(var2);
  433.       } else if (var1 > var2) {
  434.          throw new StringIndexOutOfBoundsException(var2 - var1);
  435.       } else {
  436.          return new String(this.value, var1, var2 - var1);
  437.       }
  438.    }
  439.  
  440.    public AbstractStringBuilder insert(int var1, char[] var2, int var3, int var4) {
  441.       if (var1 >= 0 && var1 <= this.length()) {
  442.          if (var3 >= 0 && var4 >= 0 && var3 <= var2.length - var4) {
  443.             int var5 = this.count + var4;
  444.             if (var5 > this.value.length) {
  445.                this.expandCapacity(var5);
  446.             }
  447.  
  448.             System.arraycopy(this.value, var1, this.value, var1 + var4, this.count - var1);
  449.             System.arraycopy(var2, var3, this.value, var1, var4);
  450.             this.count = var5;
  451.             return this;
  452.          } else {
  453.             throw new StringIndexOutOfBoundsException("offset " + var3 + ", len " + var4 + ", str.length " + var2.length);
  454.          }
  455.       } else {
  456.          throw new StringIndexOutOfBoundsException(var1);
  457.       }
  458.    }
  459.  
  460.    public AbstractStringBuilder insert(int var1, Object var2) {
  461.       return this.insert(var1, String.valueOf(var2));
  462.    }
  463.  
  464.    public AbstractStringBuilder insert(int var1, String var2) {
  465.       if (var1 >= 0 && var1 <= this.length()) {
  466.          if (var2 == null) {
  467.             var2 = "null";
  468.          }
  469.  
  470.          int var3 = var2.length();
  471.          int var4 = this.count + var3;
  472.          if (var4 > this.value.length) {
  473.             this.expandCapacity(var4);
  474.          }
  475.  
  476.          System.arraycopy(this.value, var1, this.value, var1 + var3, this.count - var1);
  477.          var2.getChars(this.value, var1);
  478.          this.count = var4;
  479.          return this;
  480.       } else {
  481.          throw new StringIndexOutOfBoundsException(var1);
  482.       }
  483.    }
  484.  
  485.    public AbstractStringBuilder insert(int var1, char[] var2) {
  486.       if (var1 >= 0 && var1 <= this.length()) {
  487.          int var3 = var2.length;
  488.          int var4 = this.count + var3;
  489.          if (var4 > this.value.length) {
  490.             this.expandCapacity(var4);
  491.          }
  492.  
  493.          System.arraycopy(this.value, var1, this.value, var1 + var3, this.count - var1);
  494.          System.arraycopy(var2, 0, this.value, var1, var3);
  495.          this.count = var4;
  496.          return this;
  497.       } else {
  498.          throw new StringIndexOutOfBoundsException(var1);
  499.       }
  500.    }
  501.  
  502.    public AbstractStringBuilder insert(int var1, CharSequence var2) {
  503.       if (var2 == null) {
  504.          var2 = "null";
  505.       }
  506.  
  507.       return var2 instanceof String ? this.insert(var1, (String)var2) : this.insert(var1, (CharSequence)var2, 0, ((CharSequence)var2).length());
  508.    }
  509.  
  510.    public AbstractStringBuilder insert(int var1, CharSequence var2, int var3, int var4) {
  511.       if (var2 == null) {
  512.          var2 = "null";
  513.       }
  514.  
  515.       if (var1 >= 0 && var1 <= this.length()) {
  516.          if (var3 >= 0 && var4 >= 0 && var3 <= var4 && var4 <= ((CharSequence)var2).length()) {
  517.             int var5 = var4 - var3;
  518.             if (var5 == 0) {
  519.                return this;
  520.             } else {
  521.                int var6 = this.count + var5;
  522.                if (var6 > this.value.length) {
  523.                   this.expandCapacity(var6);
  524.                }
  525.  
  526.                System.arraycopy(this.value, var1, this.value, var1 + var5, this.count - var1);
  527.  
  528.                for(int var7 = var3; var7 < var4; ++var7) {
  529.                   this.value[var1++] = ((CharSequence)var2).charAt(var7);
  530.                }
  531.  
  532.                this.count = var6;
  533.                return this;
  534.             }
  535.          } else {
  536.             throw new IndexOutOfBoundsException("start " + var3 + ", end " + var4 + ", s.length() " + ((CharSequence)var2).length());
  537.          }
  538.       } else {
  539.          throw new IndexOutOfBoundsException("dstOffset " + var1);
  540.       }
  541.    }
  542.  
  543.    public AbstractStringBuilder insert(int var1, boolean var2) {
  544.       return this.insert(var1, String.valueOf(var2));
  545.    }
  546.  
  547.    public AbstractStringBuilder insert(int var1, char var2) {
  548.       int var3 = this.count + 1;
  549.       if (var3 > this.value.length) {
  550.          this.expandCapacity(var3);
  551.       }
  552.  
  553.       System.arraycopy(this.value, var1, this.value, var1 + 1, this.count - var1);
  554.       this.value[var1] = var2;
  555.       this.count = var3;
  556.       return this;
  557.    }
  558.  
  559.    public AbstractStringBuilder insert(int var1, int var2) {
  560.       return this.insert(var1, String.valueOf(var2));
  561.    }
  562.  
  563.    public AbstractStringBuilder insert(int var1, long var2) {
  564.       return this.insert(var1, String.valueOf(var2));
  565.    }
  566.  
  567.    public AbstractStringBuilder insert(int var1, float var2) {
  568.       return this.insert(var1, String.valueOf(var2));
  569.    }
  570.  
  571.    public AbstractStringBuilder insert(int var1, double var2) {
  572.       return this.insert(var1, String.valueOf(var2));
  573.    }
  574.  
  575.    public int indexOf(String var1) {
  576.       return this.indexOf(var1, 0);
  577.    }
  578.  
  579.    public int indexOf(String var1, int var2) {
  580.       return String.indexOf(this.value, 0, this.count, var1.toCharArray(), 0, var1.length(), var2);
  581.    }
  582.  
  583.    public int lastIndexOf(String var1) {
  584.       return this.lastIndexOf(var1, this.count);
  585.    }
  586.  
  587.    public int lastIndexOf(String var1, int var2) {
  588.       return String.lastIndexOf(this.value, 0, this.count, var1.toCharArray(), 0, var1.length(), var2);
  589.    }
  590.  
  591.    public AbstractStringBuilder reverse() {
  592.       boolean var1 = false;
  593.       int var2 = this.count - 1;
  594.  
  595.       for(int var3 = var2 - 1 >> 1; var3 >= 0; --var3) {
  596.          char var4 = this.value[var3];
  597.          char var5 = this.value[var2 - var3];
  598.          if (!var1) {
  599.             var1 = var4 >= '\ud800' && var4 <= '\udfff' || var5 >= '\ud800' && var5 <= '\udfff';
  600.          }
  601.  
  602.          this.value[var3] = var5;
  603.          this.value[var2 - var3] = var4;
  604.       }
  605.  
  606.       if (var1) {
  607.          for(int var6 = 0; var6 < this.count - 1; ++var6) {
  608.             char var7 = this.value[var6];
  609.             if (Character.isLowSurrogate(var7)) {
  610.                char var8 = this.value[var6 + 1];
  611.                if (Character.isHighSurrogate(var8)) {
  612.                   this.value[var6++] = var8;
  613.                   this.value[var6] = var7;
  614.                }
  615.             }
  616.          }
  617.       }
  618.  
  619.       return this;
  620.    }
  621.  
  622.    public abstract String toString();
  623.  
  624.    final char[] getValue() {
  625.       return this.value;
  626.    }
  627. }
  628.